package com.starblink.basic.util;


import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

import java.util.Objects;
import java.util.Stack;

import androidx.annotation.NonNull;

import com.blankj.utilcode.util.AppUtils;
import com.blankj.utilcode.util.ProcessUtils;
import com.jakewharton.processphoenix.ProcessPhoenix;


/**
 * 管理activity的manage
 */
public class ActivityStackManage {

    private static Stack<Activity> activityStack;

    private static Activity topActivity = null;


    /**
     * 获取到当前最上层的activity 不稳定
     */
    public static Activity getTopActivity() {
        return topActivity;
    }

    public static void setTopActivity(Activity activity) {
        topActivity = activity;
    }


    /**
     * 添加Activity到堆栈
     */
    public static void addActivity(Activity activity) {
        if (activityStack == null) {
            activityStack = new Stack();
        }
        activityStack.push(activity);
    }

    //获取activity栈
    public static Stack<Activity> getActivityStack() {
        return activityStack;
    }

    /**
     * 只是移除栈，不用结束Activity  注意哦 没有调用finish
     * 只是移除栈，不用结束Activity  注意哦 没有调用finish
     * 只是移除栈，不用结束Activity  注意哦 没有调用finish
     * 要同时finish 请调用 finishActivity
     */
    public static void removeActivityStack(Activity activity) {
        activityStack.remove(activity);
    }


    /**
     * 获取当前Activity（堆栈中最后一个压入的）
     */
    public static Activity currentActivity() {
        return activityStack.lastElement();
    }

    /**
     * 结束当前Activity（堆栈中最后一个压入的）
     */
    public static void finishCurrentActivity() {
        Activity activity = activityStack.pop();
        activity.finish();
    }

    /**
     * 将栈顶指定数量Activity出栈并结束
     *
     * @param count
     */
    public static void finishLastActivities(int count) {
        int size = Math.min(count, activityStack.size());
        for (int i = 0; i < size; i++) {
            Activity activity = activityStack.pop();
            if (!activity.isFinishing()) {
                activity.finish();
            }
        }
    }

    /**
     * 结束指定的Activity
     */
    public static void finishActivity(Activity activity) {

        if (activity != null) {
            activityStack.remove(activity);
            if (!activity.isFinishing()) {
                activity.finish();
            }
        }
        //正式代码
    }

    /**
     * 结束指定类名的Activity
     */
    public static void finishActivity(Class<?> cls) {
        for (Activity activity : activityStack) {
            if (activity.getClass().equals(cls)) {
                finishActivity(activity);
            }
        }
    }

    /**
     * 结束所有Activity
     */
    public static void finishAllActivity() {
        for (Activity activity : activityStack) {
            if (activity != null) {
                activity.finish();
            }
        }
        activityStack.clear();
    }

    /**
     * 关闭所有界面 返回MainActivity
     *
     * @note 注意：如果启动APP后，在MainActivity的onCreate()中，调用该方法，会有问题：
     * 此时APP启动页虽然结束但尚未从activityStack中移除，因此activityStack栈底是APP启动页，上面是MainActivity
     * 此时会将MainActivity结束。
     */
    public static void toMainActivity() {
        //        Log.e("dss", "activityStack.size()=" + activityStack.size());
//        Log.e("dss", "activityStack=" + activityStack);
        while (activityStack.size() != 1) {
            Activity activity = activityStack.pop();
//            Log.e("dss", "finishActivity=" + activity.toString());
            finishActivity(activity);
        }
    }


    public static boolean isMainActivity() {
        //多进程 栈中数量无法准确判断是否是首页
        if (!ProcessUtils.getCurrentProcessName().equals(AppUtils.getAppPackageName())) {
            return false;
        }
        return activityStack.size() == 1;
    }


    //
    public boolean isTopActivity(Activity activity) {
        ActivityManager am = (ActivityManager) activity.getSystemService(Context.ACTIVITY_SERVICE);
        ComponentName cn = am.getRunningTasks(1).get(0).topActivity;
        return cn.getClassName().equals(activity.getClass().getName());
    }


    /**
     * 退出应用程序
     * https://blog.csdn.net/liranke/article/details/13772253
     */

    public static void AppExit() {
        try {
            System.exit(0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 重启应用 轻量级 通过清栈触发应用重启。但不会重启 application ，与应用相关的静态变量也会更重启前一样。单例 静态等变量不会重置
     *
     * @param context
     */
    public static void restartLightWeightApp(Context context) {
        final Intent intent = context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        context.startActivity(intent);
    }

//    /**
//     * 重启应用 终止进程
//     * https://blog.csdn.net/qq_28851933/article/details/128836679
//     *
//     * @param   这里是用getLaunchIntentForPackage进行重启，延迟了重启的操作。在重启之前先把程序给杀掉
//     *                <p>
//     *                getBaseContext()： 由构造函数指定或setBaseContext()设置的上下文
//     *                getApplicationContext()：整个应用程序生命周期的应用程序上下文,当应用程序将销毁时,它也将销毁
//     *                getSystemService(Context.ALARM_SERVICE) ：系统服务,定时后台重启应用
//     *                ————————————————
//     *                版权声明：本文为CSDN博主「Tan.]der」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
//     *                原文链接：https://blog.csdn.net/weixin_45265547/article/details/125163865
//     */
//    public static void killAppAndRestart() {
//        toMainActivity();
//        Intent intent = CommUtils.getContext().getPackageManager()
//                .getLaunchIntentForPackage(CommUtils.getContext().getPackageName());
//        PendingIntent restartIntent;
//        //https://blog.csdn.net/yubo_725/article/details/124413000
//        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
//            restartIntent = PendingIntent.getActivity(CommUtils.getContext(), 123, intent, PendingIntent.FLAG_IMMUTABLE);
//        } else {
//            restartIntent = PendingIntent.getActivity(CommUtils.getContext(), 123, intent, PendingIntent.FLAG_ONE_SHOT);
//        }
//        AlarmManager mgr = (AlarmManager) CommUtils.getContext().getSystemService(Context.ALARM_SERVICE);
//        // 1秒钟后重启应用
//        mgr.set(AlarmManager.RTC, System.currentTimeMillis() + 2000, restartIntent);
//        System.exit(0);
//
//        ProcessPhoenix.triggerRebirth(CommUtils.getContext());
//    }

    public static void killAppAndRestart() {
        ProcessPhoenix.triggerRebirth(CommUtils.getContext());
    }



//    public static void exitApp() {
//        ActivityManager am = (ActivityManager) CommUtils.getContext().getSystemService(Context.ACTIVITY_SERVICE);
//        am.killBackgroundProcesses(CommUtils.getContext().getPackageName());
//        System.exit(0);
//    }

}